home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
C/C++ Users Group Library 1996 July
/
C-C++ Users Group Library July 1996.iso
/
vol_400
/
443_01
/
doc
/
info
/
cncl.info-6
< prev
next >
Encoding:
Amiga
Atari
Commodore
DOS
FM Towns/JPY
Macintosh
Macintosh JP
Macintosh to JP
NeXTSTEP
RISC OS/Acorn
Shift JIS
UTF-8
Wrap
GNU Info File
|
1996-01-04
|
48.8 KB
|
1,849 lines
This is Info file cncl.info, produced by Makeinfo-1.63 from the input
file cncl.texi.
This file documents the use of CNCL, the Communication Networks Class
Library.
Copyright (C) 1993-1996, Communication Networks.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this
manual into other languages, under the above conditions for modified
versions.
File: cncl.info, Node: EZDWindow, Next: EZDDiagWin, Prev: EZDPushButton, Up: EZD Interface
EZDWindow -- Interface to EZD Window
====================================
SYNOPSIS
--------
`#include<CNCL/EZDWindow>'
TYPE
----
`CN_EZDWINDOW'
* Menu:
BASE CLASSES
------------
* EZD:: Base Class for EZD Graphic Objects
DERIVED CLASSES
---------------
RELATED CLASSES
---------------
* EZDObject:: Interface to EZD Objects
* EZDDrawing:: Interface to EZD Drawings
* EZDPushButton:: Interface to EZD Push-Button
DESCRIPTION
-----------
With EZD a drawing can only be displayed when it is mapped into a
window. For this, `EZDWindow' creates named windows and maps drawings
into it. The window is always displayed in the upper left corner of the
screen and is `w_width' pixels wide and `w_heigth' pixels high. The
background color is white and the foreground color is black.
Note: If the named window already exists, the old window is deleted.
Windows are only visible if drawings are displayed in them.
Constructors:
`EZDWindow();'
`EZDWindow(CNParam *param);'
`EZDWindow(int w, int h);'
`EZDWindow(int x, int y, int w, int h);'
`EZDWindow(const CNString &name, int w, int h);'
`EZDWindow(const CNString &name, int x, int y, int w, int h);'
`EZDWindow(const CNString &name, const CNString &title, int w, int h)'
`EZDWindow(const CNString &name, const CNString &title, int x, int y, int w, int h);'
Creates the window named `name' (default: "win") with the title
`title' (default setting equals `name'). The window is `w' pixels
wide (default: 200) and `h' pixels high (default: 200). It is
positioned at the coordinates `(x,y)' (default: (-1,-1)).
Destructor:
`~EZDWindow();'
Deinitilizes (deletes) the current window.
In addition to the member functions required by CNCL, `EZDWindow'
provides:
`int heigth() const;'
`int width() const;'
`int wherex() const;'
`int wherey() const;'
Returns the width, heigth or (x,y) position of the current window.
`void overlay(EZDDrawing *d);'
`void underlay(EZDDrawing *d);'
Overlays/undelays the drawing `d' over the existing drawings in the
current window.
`void scale_drawing(EZDDrawing *draw, const int origin_x, const int origin_y, const float d_scale_x, const float d_scale_y, const int scale_linewidth);'
Maps the drawing`draw' with a cartesian coordinate system onto the
current window. The `origin_(x,y)' parameters specifie the size of
the origin coordinate system, `d_scale_(x,y)' and
`scale_linewidth' are the scaling factors.
`void set_zoom(EZDDrawing *, const float factor);'
Zooms the drawing by `factor'.
`void set_norm(EZDDrawing *);'
Sets the drawing back to normalsize.
`void set_auto_resize(const int nargs, EZDDrawing * ...);'
Resizes all drawings of the argument. `nargs' is the number of
arguments.
`void delete_drawing(EZDDrawing *d);'
Deltes the drawing `d' in the current window.
`void print_window(const CNString &filename);'
Prints the current window as a postscript file on disk.
File: cncl.info, Node: EZDDiagWin, Next: EZDTextWin, Prev: EZDWindow, Up: EZD Interface
EZDDiagWin -- Extra window with x-y diagram
===========================================
SYNOPSIS
--------
`#include <CNCL/EZDDiagWin.h>'
TYPE
----
`CN_EZDDIAGWIN'
* Menu:
BASE CLASSES
------------
* EZD:: Base class for ezd graphic objects
DERIVED CLASSES
---------------
RELATED CLASSES
---------------
DESCRIPTION
-----------
`EZDDiagWin' craetes a named window including a diagram. Actually there
are three different styles (as an enum) implemeted in this class:
* DOT : draws the diagram in form of dots
* LINE : draws a line
* HISTO: draws a histogram
Constructors:
`EZDDiagWin();'
`EZDDiagWin(CNParam *param);'
`EZDDiagWin(int w, int h, Style s=LINE);'
`EZDDiagWin(CNStringR n, int w, int h, Style s=LINE);'
`EZDDiagWin(CNStringR n, CNStringR title, int w, int h, Style s=LINE);'
`EZDDiagWin(CNStringR n, CNStringR title, int w, int h, int st, CNStringR cd, CNStringR cb, Style s=LINE);'
Initializes a named `EZDDiagwin'. `title' is the title of the
window, `w' and `h' the window's width and height. `st' is the
size of a step between two values (default: 1), `cd' is the color
of the diagram, `cb' the color of the bar (out-of-range display),
`s' the style of the diagram.
In addition to the member functions required by CNCL, `CNEZDDiagWin'
provides:
`void style(Style s);'
Changes the style to `s'.
`void add(int v);'
Adds a new value `v' at the current x-position to the diagram.
`void clear();'
Clears the diagram window.
`void set();'
Sets current drawing to diagram window drawing.
File: cncl.info, Node: EZDTextWin, Next: EZDDiag, Prev: EZDDiagWin, Up: EZD Interface
EZDTextWin -- ezd window for easy text display
==============================================
SYNOPSIS
--------
`#include <CNCL/EZDTextWin.h>'
TYPE
----
`CN_EZDTEXTWIN'
* Menu:
BASE CLASSES
------------
* EZD:: Base Class for EZD Graphic Objects
DERIVED CLASSES
---------------
RELATED CLASSES
---------------
DESCRIPTION
-----------
`EZDTextWin' provides an easy possibility for a text display in an EZD
window.
Constructors:
`EZDTextWin(CNParam *param);'
`EZDTextWin(int r=ROWS, int c=COLS, int ix=INCX, int iy=INCY);'
`EZDTextWin(int r, int c, int ix, int iy, CNStringR f);'
`EZDTextWin(CNStringR n, int r=ROWS, int c=COLS, int ix=INCX, int iy=INCY);'
`EZDTextWin(CNStringR n, int r, int c, int ix, int iy, CNStringR f);'
`EZDTextWin(CNStringR n, CNStringR t, int r=ROWS, int c=COLS, int ix=INCX, int iy=INCY);'
`EZDTextWin(CNStringR n, CNStringR t, int r, int c, int ix, int iy, CNStringR f);'
Initializes `EZDTextWin'. `r' is the number of rows, `c' the
number of columns. `ix' and `iy' are the x-size of one column /
y-size of one row. Thus the total size of the window is (`c' *
`ix') by (`r' * `iy'). The strings are the window's name (`n'),
it's title (`t') and the font (`f'). No text is displayed in the
window yet.The constant default values are:
ROWS : 24, COLS : 80, INCX : 9, INCY : 15
In addition to the member functions required by CNCL, `EZDTextWin'
provides:
`int width() const;'
`int height() const;'
Returns the window's width or height.
`int cols() const;'
`int rows() const;'
Returns the number of rows or cols in the window.
`int incx() const;'
`int incy() const;'
Returns the x-size of a column or the y-size of a row.
`int row_to_y(int r) const;'
`int col_to_x(int c) const;'
Returns the y-/x-coordinate of the r-th row/ c-th column.
`void clear();'
Clears the whole text window, painting everything white.
`void clear(int r, int c, int l);'
Clears a window area. `r' is the row and `c' the column wich is
cleared, (`l' * `incx') the horizontal length in this area wich is
painted white.
`void set();'
Sets the current drawing to text window drawing.
`void hline(int r, int c, int l);'
`void vline(int r, int c, int l);'
Draws a vertical/horizontal line of length `l', begining at the
position described by row `r' and col `c'.
`void add(int r, int c, CNStringR s);'
`void add(int r, int c, CNStringR s, CNStringR f);'
Draws the text `s' in row `r', column `c'. Possible old text at
this position (length of string s) is wiped out. `f' is the font.
File: cncl.info, Node: EZDDiag, Next: EZDBlock, Prev: EZDTextWin, Up: EZD Interface
EZDDiag -- x-y diagram as an EZDObject
======================================
SYNOPSIS
--------
`#include <CNCL/EZDDiag.h>'
TYPE
----
`CN_EZDDIAG'
* Menu:
BASE CLASSES
------------
* EZDObject:: Interface to ezd object
DERIVED CLASSES
---------------
RELATED CLASSES
---------------
* EZDDiagWin:: Extra window with x-y diagram
DESCRIPTION
-----------
`EZDDiag' creates a diagram as an ezd object. Actually there are three
different styles (as an enum) implemeted in this class:
* DOT : draws the diagram in form of dots
* LINE : draws a line
* HISTO: draws a histogram
Constructors:
`EZDDiag();'
`EZDDiag(CNParam *param)'
`EZDDiag(int w, int h, Style s=LINE);'
`EZDDiag(int w, int h, int x, int y, Style s=LINE);'
`EZDDiag(const CNString &name, int w, int h, int x, int y, Style s=LINE);'
`EZDDiag(int w, int h, int x, int y, Style s, CNString cd, CNString cb);'
`EZDDiag(const CNString &name, int w, int h, int x, int y, Style s, CNString cd, CNString cb);'
Initializes `EZDDiag' at the position `(x,y)', default (0,0), of
the current drawing as a named ezd object. `w' (default: 200) and
`h' (100) are the object`s width and heigth. `cd' ("black") and
`cb' ("red") are color-settings for the diagram and the bar which
is drawn if the value is out of the given range - e.g. negative
values or values > 100 at the default setting. The possible styles
`s' are described above. The object is drawn frameless, but a
frame can be added, see the functions below.
In addition to the member functions required by CNCL, `EZDDiag'
provides:
`void style(Style s);'
Sets the style of the diagram to `s'.
`void set_color_draw(CNString c);'
Sets the drawing color to `c'.
`void set_color_bar(CNString c);'
Sets the color of the bar (out-of-range display) to `c'.
`void add(int v);'
Adds the value `v' to the diagram.
`void clear();'
Clears the diagram.
`virtual void redraw();'
Redraws the diagram.
`void set_frame();'
Sets a frame to the diagram.
File: cncl.info, Node: EZDBlock, Next: EZDPopUp, Prev: EZDDiag, Up: EZD Interface
EZDBlock -- Block with small rectangles for bit display
=======================================================
SYNOPSIS
--------
`#include <CNCL/EZDBlock.h>'
TYPE
----
`CN_EZDBLOCK'
* Menu:
BASE CLASSES
------------
* EZDObject:: Interface to EZD Object
DERIVED CLASSES
---------------
RELATED CLASSES
---------------
DESCRIPTION
-----------
`EZDBlock' draws a block of several square rectangles. Each
rectangle's side is `bsize' long, so that the total size of the block
is determined by the number of rows and cols. Each rectangle's color is
representing the state of a bit, `black' if the bit is turned on and
`white' if turned off. The frame of all rectangles is 1 pixel by
default.
Constructors:
`EZDBlock();'
`EZDBlock(CNParam *param);'
`EZDBlock(const CNString &name, int x, int y, int r, int c, int b);'
Initializes the `EZDBlock' (does not draw it yet). `&name' is the
`EZDObjects' name, `(x,y)' its minimum coordinates (default
(0,0)). The block is made out of r by c square rectangles, each
side b long. At the initialzation all bits are assumed to be set
off (drawn white).
In addition to the member functions required by CNCL, `EZDBlock'
provides:
`virtual void redraw();'
Draws / redraws the whole block.
`void on(int b);'
`void off(int b);'
Turns bit on(black)/off(white) and sets the color for it; redraws
the (whole) block.
File: cncl.info, Node: EZDPopUp, Next: EZDQueue, Prev: EZDBlock, Up: EZD Interface
EZDPopUp -- Interface to EZD popup menu
=======================================
SYNOPSIS
--------
`#include <CNCL/EZDPopUp.h>'
TYPE
----
`CN_EZDPOPUP'
* Menu:
BASE CLASSES
------------
* EZDObject:: Interface to EZD Object
DERIVED CLASSES
---------------
RELATED CLASSES
---------------
DESCRIPTION
-----------
`EZDPopUp' is the interface to ezd's popup menus. It defines a named
scheme that is called as the action on a button down event to display a
popup menu. The scheme's functions, displayed names and all other
parameters are stored in the struct `MENU'. When button 1 is pressed
down, the menu comes up. Releasing the button executes the action
associated with the current menu entry. Moving the mouse outside the
menu without releasing the button will cause the menu to disappear, no
action is executed. For additional information see the ezd manual.
Constructors:
`EZDPopUp();'
`EZDPopUp(CNParam *param);'
`EZDPopUp(const int nmenu, const MENU *menu ...);'
Initializes the conection to ezd's popup with a variable size of
parameters. `nmenu' is the total number of menu items, `MENU' a
struct descibed below.
In addition to the member functions required by CNCL, `EZDPopUp'
provides:
`typedef struct menue MENU;'
`MENU' is a struct of :
``int posx, posy''
minimum (x,y) coordinates of the menu
``int height''
height of the menu
``CNString title''
menu title, used as name of the scheme
``CNString t_color''
title color
``CNString b_color, f_color''
color of the background and the frame
``CNString* inhalt''
menu entries
``CNString* scheme_func''
scheme functions
``int anz''
total number of menu entries
Take note that the [i]th entrie and the [i]th function are
associated with each other. If `anz' is larger than the
correct number the program will terminate, if it is smaller,
all entries after that number are set inactive.
File: cncl.info, Node: EZDQueue, Next: EZDServer, Prev: EZDPopUp, Up: EZD Interface
EZDQueue -- Graphical Representation of a Queue
===============================================
SYNOPSIS
--------
`#include <CNCL/EZDQueue.h>'
TYPE
----
`CN_EZDQUEUE'
* Menu:
BASE CLASSES
------------
* EZDObject:: Interface to EZD Objects
DERIVED CLASSES
---------------
RELATED CLASSES
---------------
* EZDServer:: Graphical Representation of a Server
DESCRIPTION:
------------
`EZDQueue' is the graphical representation of a queue. This drawing is
handled as an `EZDObject', in which x is the most left and y the middle
axis' coordinate. The bar, itself an `EZDObject', is representing the
amount of tasks waiting inside the queue.
Constructors:
`EZDQueue();'
`EZDQueue(Param *param);'
`EZDQueue(int x, int y, int width = WIDTH, int heigth = HEIGTH, int tail = TAIL);'
`EZDQueue(const CNString &name, int x, int y, int width = WIDTH, int heigth = HEIGTH, int tail = TAIL);'
Initializes an `EZDQueue' as an `EZDObject' (default object name :
"queue" ) inside the current drawing at the coordinates `(x,y)' (
default value (0,0) ). Width ( 100 pixels ) and heigth ( 20 pixels
) are the queue body's rectangle size measured in pixels, tail (
20 pixels ) the tail's length.
In addition to the member functions required by CNCL, `EZDQueue'
provides:
`int left() const;'
`int rigth() const;'
`int upper() const;'
`int lower() const;'
Returns the left, right, upper or lower coordinate of the object
queue inside the current drawing.
`virtual void redraw();'
Redraws this queue in the current drawing.
`int length() const;'
`int get_length() const;'
`void length(int l);'
`void set_length(int l);'
Get/set length of the queue-bar.
`void color(const CNString &c);'
Sets the color of the queue-bar to `c' and redraws the queue.
File: cncl.info, Node: EZDServer, Next: EZDText, Prev: EZDQueue, Up: EZD Interface
EZDServer -- Graphical Representation of a Server
=================================================
SYNOPSIS
--------
`#include <CNCL/EZDServer.h>'
TYPE
----
`CN_EZDSERVER'
* Menu:
BASE CLASSES
------------
* EZDObject:: Interface to EZD Objects
DERIVED CLASSES
---------------
RELATED CLASSES
---------------
* EZDQueue:: Graphical Representation of a Queue
DESCRIPTION:
------------
`EZDServer' is the graphical representation of a server. This drawing
is handled as an `EZDObject', in which x is the most left and y the
middle axis' coordinate.
Constructors:
`EZDServer();'
`EZDServer(CNParan *param);'
`EZDServer(int x, int y , int radius = RADIUS);'
`EZDServer(const CNString &name, int x, int y, int radius=RADIUS);'
Initializes an `EZDServer' as an `EZDObject' (default object name
: "server" ) inside the current drawing at the coordinates `(x,y)'
( default value (0,0) ) with `radius' ( default 20 pixels ).
In addition to the member functions required by CNCL, `EZDServer'
provides:
`virtual void redraw();'
Redraws the server in the current drawing.
`void color(const CNString &c);'
Sets the color of the server to `c' and redraws the server in the
current drawing.
File: cncl.info, Node: EZDText, Next: EZDTimer, Prev: EZDServer, Up: EZD Interface
EZDText -- EZD Object with Text
===============================
SYNOPSIS
--------
`#include <CNCL/EZDText.h>'
TYPE
----
`CN_EZDTEXT'
* Menu:
BASE CLASSES
------------
* EZDObject:: Interface to EZD Objects
DERIVED CLASSES
---------------
RELATED CLASSES
---------------
DESCRIPTION:
------------
`EZDText' writes text into a clear rectangle. The rectangle is handled
as an `EZDObject', its size is automatically as large as necessary to
hold the text in the given `font' and `(x,y)' are its minimum
coordinates in the current drawing. Note that the `font' name is
specified as a string in X font name terminology.
Constructors:
`EZDText();'
`EZDText(CNParam *param);'
`EZDText(int x, int y, const CNString &text);'
`EZDText(const CNString &name, int x, int y, const CNString &text);'
`EZDText(int x, int y, const CNString &text, const CNString &font);'
`EZDText(const CNString &name, int x, int y, const CNString &text, const CNString &font);'
Initializes the `EZDObject' and displays the `text' in the current
drawing at the `(x,y)' coordinates. If no `EZDObject' name is
chosen it is called "text".
In addition to the member functions required by CNCL, `EZDText'
provides:
`virtual void redraw();'
Redraws the `text' in the current drawing.
`void set_text(const CNString &t);'
`void set_text_val(int x);'
`void set_text_val(const CNString &t, int x);'
`void set_text_val(double x);'
`void set_text_val(const CNString &t, double x);'
Creates `text' out of text, integer or double and displays it in
the current drawing.
File: cncl.info, Node: EZDTimer, Next: CNFClause, Prev: EZDText, Up: EZD Interface
EZDTimer -- Graphical Representation of a Timer
===============================================
SYNOPSIS
--------
`#include <CNCL/EZDTimer.h>'
TYPE
----
`CN_EZDTIMER'
* Menu:
BASE CLASSES
------------
* EZDObject:: Interface to ezd objects
DERIVED CLASSES
---------------
RELATED CLASSES
---------------
DESCRIPTION
-----------
`EZDTimer' draws an `EZDObject' representing a timer. It is realized as
a filled pie arc inside of an oval. The `(x,y)' coordinates are the
center coordinates of the object in the current drawing. The timer
starts (by default) at 270 degrees (12 o'clock position) as an offset
value. The pie dimension angle (in degrees) is the pie's size. The
default colors are black on white backround. Please note that the
timer doesn't count automatically, each change of the shown value has
to be programmed.
Constructors:
`EZDTimer();'
`EZDTimer(CNParam *param);'
`EZDTimer(int x, int y, int radiusx=RADIUSX, int radiusy=RADIUSY);'
`EZDTimer(const CNString &name, int x, int y, int radiusx=RADIUSX, int radiusy=RADIUSY);'
Initializes the timer as an `EZDObject'. The default object's name
is "Timer". Radiusx and radiusy are the oval's radius in (x,y)
direction, measured in pixels (default:(5,5))
In addition to the member functions required by CNCL, `EZDTimer'
provides:
`int left();'
`int right();'
`int upper();'
`int lower();'
Returns the oval's most left/right/upper/lower layout coordinates
in pixels.
`virtual void redraw();'
Redraws the timer in the current drawing.
`int offset_angle()'
`int get_offset_angle()'
Returns the timer's current offset angle.
`void offset_angle(int a);'
`void set_offset_angle(int a);'
Sets the timer's offset angle to `a' degrees and redraws the pie.
`int angle();'
`int get_angle();'
Returns the timer's pie dimension angle.
`void angle(int a);'
`void set_angle(int a);'
Sets the timer's pie dimension angle to `a' degrees and redraws
the pie.
`void color(const CNString &c);'
Sets the timer's color to `c' and redraws the timer.
`void activate();'
`void deactivate();'
Activates/deactivates an additional oval in 4 pixels distance to
the timer.
`void active_color(const CNString &c);'
Sets the additional oval's color to `c' but does not redraw it.
File: cncl.info, Node: Fuzzy, Next: Persistent, Prev: EZD Interface, Up: Top
Fuzzy classes
*************
CNCL provides a set of classes for building fuzzy inference engines.
Available are fuzzy sets, fuzzy variables, and a inference engine based
on fuzzy rules. The membership values are normalized ( by default ), but
can be changed to max and min values in different classes. All fuzzy
sets and functions are realized with crisply defined membership values (
type 1 fuzzy sets and functions ).
Currently prod-min inference is used and a center-of-gravity output
defuzzification. This will be extended in a future release, providing
different operators for aggregation, inference, and accumulation. Up to
now two different fuzzy set representations are implemented:
LR-representation and arrays.
For more information about fuzzy logic see:
Zimmermann,. H.-J. [1991]. Fuzzy Set Theory And Its Applications.
Kluwer Accademic Publishers.
Additionally, the FAQ of the newsgroup "comp.ai.fuzzy" should be
recommended in this context.
* Menu:
Fuzzy
-----
* CNFClause:: Clause of a fuzzy rule
* CNFVar:: Fuzzy variable
* CNFRule:: Fuzzy rule
* CNFRuleBase:: Rule base and Fuzzy inference engine
* CNFSet:: Fuzzy set abstract base class
* CNFSetArray:: Fuzzy set based on array with membership values
* CNFSetLR:: Fuzzy set with L and R functions
* CNFSetTrapez:: Fuzzy set with trapezium function
* CNFSetTriangle:: Fuzzy set with triangle function
* CNFNumTriangle:: Fuzzy numbers (triangle)
File: cncl.info, Node: CNFClause, Next: CNFVar, Prev: EZDTimer, Up: Fuzzy
CNFClause -- Clause of a fuzzy rule
===================================
SYNOPSIS
--------
`#include <CNCL/FClause.h>'
TYPE
----
`CN_FCLAUSE'
* Menu:
BASE CLASSES
------------
* CNObject:: Root of the CNCL hierarchy
DERIVED CLASSES
---------------
RELATED CLASSES
---------------
DESCRIPTION
-----------
A `CNFClause' is basically a structure containing a fuzzy variable /
fuzzy value pair. The members
CNFVar *var; // Linguistic variable
CNFSet *value; // Linguistic value
are public accessible.
Constructors:
`CNFClause();'
`CNFClause(CNParam *param);'
`CNFClause(CNFVar *xvar, CNFSet *xset);'
`CNFClause(CNFVar &xvar, CNFSet &xset);'
Initializes a `CNFVar' and a `CNFSet' to a `CNFClause'.
In addition to the member functions required by CNCL, `CNFClause'
provides:
`void print_clause(ostream &strm, bool lhs) const;'
Prints the public accessible variables on the output stream
`&strm'.
File: cncl.info, Node: CNFVar, Next: CNFRule, Prev: CNFClause, Up: Fuzzy
CNFVar -- Fuzzy variable
========================
SYNOPSIS
--------
`#include <CNCL/FVar.h>'
TYPE
----
`CN_FVAR'
* Menu:
BASE CLASSES
------------
* CNNamed:: CNObject with name
DERIVED CLASSES
---------------
RELATED CLASSES
---------------
DESCRIPTION
-----------
This class creates a fuzzy variable and its corrosponding linguistic
variable. For example, the linguistic variable "temperature" migth be
programmed this way:
CNFVar temp("Temperature", 0, 100);
enum { COLD, MEDIUM, WARM, HOT };
temp.add_value_set(COLD, new CNFSetTrapez("cold", 0, 10, 0, 10));
temp.add_value_set(MEDIUM, new CNFSetTrapez("medium", 20, 20, 10, 10));
temp.add_value_set(WARM, new CNFSetTrapez("warm", 30, 40, 10, 5));
temp.add_value_set(HOT, new CNFSetTrapez("hot", 40,100, 10, 0));
Here trapezium functions have been assumed as membership function, but
all other kinds of (implemented) functions are possible.
Constructors:
`CNFVar(CNParam *param);'
`CNFVar(double min = 0, double max = 1);'
`CNFVar(const CNString &xname, double min = 0, double max = 1);'
Initializes the `CNFVar'.
In addition to the member functions required by CNCL, `CNFVar' provides:
`double value( double x );'
`double set_value( double x );'
Sets the (non fuzzy) variable value to `x' and returns the old
value.
`double value() const'
`double get_value()const;'
Returns the (non-fuzzy) value.
`CNFSet* fuzzy_value( CNFSet* x );'
`CNFSet* set_fuzzy_value( CNFSet* x );'
Sets the fuzzy variable value (fuzzy set) to `x' and returns the
old value.
`CNFSet* fuzzy_value() const;'
`CNFSet* get_fuzzy_value() const;'
Returns the fuzzy value (fuzzy set).
`double xmin() const;'
`double get_xmin() const;'
`double xmax() const;'
`double get_xmax() const;'
Returns the minimum and maximum values of the variable's range.
`void add_value_set(CNFSet &fset);'
`void add_value_set(CNFSet *fset);'
`void add_value_set(int i, CNFSet &fset);'
`void add_value_set(int i, CNFSet *fset);'
Adds the fuzzy set `fset' to the array of affiliated sets, either
at position `i' (overwritting) or at the end (extending).
`CNFSet *get_value_set(int i);'
Returns the fuzzy set at array position `i'.
`double get_membership( int i);'
Gets the membership value of the fuzzy set at array position `i'.
`void print_membership();'
Computes the membership value for all fuzzy sets using the current
value and prints the result.
File: cncl.info, Node: CNFRule, Next: CNFRuleBase, Prev: CNFVar, Up: Fuzzy
CNFRule -- Fuzzy Rule
=====================
SYNOPSIS
--------
`#include <CNCL/FRule.h>'
TYPE
----
`CN_FRULE'
* Menu:
BASE CLASSES
------------
* CNObject:: Root of the CNCL hierarchy
DERIVED CLASSES
---------------
RELATED CLASSES
---------------
DESCRIPTION
-----------
Constructors:
`CNFRule();'
`CNFRule(CNParam *param);'
Initializes a `CNFRule' variable.
In addition to the member functions required by CNCL, `CNFRule'
provides:
`void add_lhs(CNFClause *clause);'
`void add_lhs(CNFClause &clause);'
`void add_rhs(CNFClause *clause);'
`void add_rhs(CNFClause &clause);'
Adds a `CNFClause' to the LHS or the RHS rules.
`int get_n_lhs() const;'
`int get_n_rhs() const;'
Gets the total number of LHS/RHS clauses.
`CNFClause* get_lhs(int i) const;'
`CNFClause* get_rhs(int i) const;'
Returns the LHS/RHS clause from array-position `i'.
`double certainty(double x);'
`double set_certainty(double x);'
Sets the certainty to `x' and returns the old certainty.
`double certainty() const;'
`double get_certainty() const;'
Returns the certainty.
`double aggregate_value() const;'
Returns the current value of the aggregation.
`double aggregate()'
Aggregates the LHS rule inputs and returns the result.
File: cncl.info, Node: CNFRuleBase, Next: CNFSet, Prev: CNFRule, Up: Fuzzy
CNFRuleBase -- Rule base and Fuzzy inference engine
===================================================
SYNOPSIS
--------
`#include <CNCL/FRuleBase.h>'
TYPE
----
`CN_FRULEBASE'
* Menu:
BASE CLASSES
------------
* CNNamed:: CNObject with name
DERIVED CLASSES
---------------
RELATED CLASSES
---------------
DESCRIPTION
-----------
Constructors:
`CNFRuleBase();'
`CNFRuleBase(CNParam *param);'
`CNFRuleBase(CNStringR name);'
Initializes the `CNFRuleBase' with `name' as the object's name.
In addition to the member functions required by CNCL, `CNFRuleBase'
provides:
`void add_rule(CNFRule *rule);'
`void add_rule(CNFRule &rule);'
Adds rule to base.
`void add_in_var(CNFVar *rule);'
`void add_in_var(CNFVar &rule);'
`void add_out_var(CNFVar *rule);'
`void add_out_var(CNFVar &rule);'
Adds input/output variables to the base.
`int get_n_rules()const;'
`int get_n_in_vars()const;'
`int get_n_out_vars()const;'
Returns the number of rules/input variables/output variables in
this base.
`int resolution()const;'
Returns the output fuzzy set resolution.
`void inference(CNFVar *var, CNFSet *set , double match, CNFSetArray &res);'
Computes the inference set for variable `var' and value `set',
using value `match' of LHS aggregation. The result is stored in the
array fuzzy set `res'.
`void evaluate(CNFVar *var, CNFSetArray &res);'
Computes output set for variable `var', combining the
`inference()' results of all rules. The result is stored in the
array fuzzy set `res'.
`void aggregate_all();'
Aggregates all rules.
`void evaluate_all();'
Evaluates all variables.
`void defuzzy_all();'
Defuzzifies all output variables.
`void debug_rules(ostream &strm=cout, int lvl=0);'
Debugs the output on `&strm' for fuzzy rules.
File: cncl.info, Node: CNFSet, Next: CNFSetArray, Prev: CNFRuleBase, Up: Fuzzy
CNFSet -- Fuzzy set abstract base class
=======================================
SYNOPSIS
--------
`#include <CNCL/FSet.h>'
TYPE
----
`CN_FSET'
* Menu:
BASE CLASSES
------------
* CNNamed:: CNObject with name
DERIVED CLASSES
---------------
* CNFSetArray:: Fuzzy set based on array with membership values
* CNFSetLR:: Fuzzy set with L and R function
RELATED CLASSES
---------------
DESCRIPTION
-----------
`CNFSet' is the abstract base class for fuzzy set realizations.
Constructors:
`CNFSet(CNParam *param);'
`CNFSet(double min = 0, double max = 1);'
`CNFSet(const CNStringR xname, double min = FSET_MIN, double max = FSET_MAX);'
Initializes a `CNFSet' with `xname' as the object's name. `min'
and `max' determine the range of the membership values. `FSET_MIN'
equals 0.0, `FSET_MAX' equals 1.0.
In addition to the member functions required by CNCL, `CNFSet' provides:
`virtual double get_membership(double x) const = 0;'
Gets the membership values for `x'.
`virtual double center_of_gravity(double min, double max) const;'
Computes the center of gravity for the defuzzyfication. (not
implemented yet)
File: cncl.info, Node: CNFSetArray, Next: CNFSetLR, Prev: CNFSet, Up: Fuzzy
CNFSetArray -- Fuzzy set based on array with membership values
==============================================================
SYNOPSIS
--------
`#include <CNCL/FSetArray.h>'
TYPE
----
`CN_FSETARRAY'
* Menu:
BASE CLASSES
------------
* CNFSet:: Fuzzy set abstract base class
DERIVED CLASSES
---------------
RELATED CLASSES
---------------
DESCRIPTION
-----------
This class realizes a fuzzy set as an array. The array is containing
the membership values and the index is its corrosponding x-value. Thus
membership values of non-integers are interpolated.
Constructors:
`CNFSetArray();'
`CNFSetArray(CNParam *param);'
`CNFSetArray(size_t sz, double min, double max);'
Initializes `CNFSetArray'.
In addition to the member functions required by CNCL, `CNFSetArray'
provides:
`virtual double get_membership(double x)const;'
Gets membership value for `x'.
`virtual double center_of_gravity(double min, double max)const;'
Computes the center of gravity.
`double get(int i) const;'
Gets the value from the array.
`void put(int i, double x);'
Puts value `x' into array at position `i'.
`double &operator [] (int i);'
Provides the direct access to the internal array.
`int get_n() const;'
Returns the size of the array.
File: cncl.info, Node: CNFSetLR, Next: CNFSetTrapez, Prev: CNFSetArray, Up: Fuzzy
CNFSetLR -- Fuzzy set with L and R functions
============================================
SYNOPSIS
--------
`#include <CNCL/FSetLR.h>'
TYPE
----
`CN_FSETLR'
* Menu:
BASE CLASSES
------------
* CNFSet:: Fuzzy set abstract base class
DERIVED CLASSES
---------------
* CNFSetTrapez:: Fuzzy set with trapezium function
RELATED CLASSES
---------------
DESCRIPTION
-----------
`CNFSetLR' provides the LR-representation of fuzzy sets. At this
representation, the interval [xm1, xm2] is considered to have the
maximum membership value ( 1 if normalized ), the left (L) and right (R)
approach is described by a shape function. Additionally, a left (alpha)
and a right (beta) slope is defined, thus the whole membership function
is:
L ( (xm1 - x) / alpha ) for x <= xm1
max (1 if normalized) for xm1 <= x <= xm2
R ( (x - xm2) / beta ) for x >= xm2
Constructors:
`CNFSetLR();'
`CNFSetLR(CNParam *param);'
`CNFSetLR(double xm1, double xm2, double xalpha, double xbeta, CNFuncType fL, CNFuncType fR);'
`CNFSetLR(double min, double max, double xm1, double xm2, double xalpha, double xbeta, CNFuncType fL, CNFuncType fR);'
`CNFSetLR(CNStringR xname, double min, double max, double xm1, double xm2 double xalpha, double xbeta, CNFuncType fL, CNFuncType fR);'
`CNFSetLR(CNStringR xname, double xm1, double xm2, double xalpha, double xbeta, CNFuncType fL, CNFuncType fR);'
Initializes `CNFSetLR'. The possible variables and their default
values are:
left/right maximum `(xm1,xm2)' (0,0), the left/right slope
`(alpha,beta)' (0,0), the left/right function `(fL,fR)'
(CNFuncLin,CNFuncLin) and the values for the named `CNFSet'
`xname,min,max' with the according default settings of that class.
In addition to the member functions required by CNCL, `CNFSetLR'
provides:
`typedef double (*CNFuncType)(double x);'
Function pointer to the functions for L/R use. Implemented
functions are:
* double CNFuncExp (double x);
exp(-x)
* double CNFuncExp2(double x);
exp(-x^2)
* double CNFuncLin (double x);
1-x
* double CNFuncSqr (double x);
1-x^2
* double CNFuncHyp (double x);
1/(1+x)
* double CNFuncHyp2(double x);
1/(1+x^2)
`virtual double get_membership(double x) const;'
Gets the membership values for `x'.
`double get_m1() const;'
Returns the value `m1' (left maximum).
`double get_m2() const;'
Returns the value `m2' (right maximum).
`double get_alpha() const;'
Returns the value `alpha' (left slope).
`double get_beta() const;'
Returns the value `beta' (right slope).
File: cncl.info, Node: CNFSetTrapez, Next: CNFSetTriangle, Prev: CNFSetLR, Up: Fuzzy
CNFSetTrapez -- Fuzzy set with trapezium function
=================================================
SYNOPSIS
--------
`#include <CNCL/FSetTrapez.h>'
TYPE
----
`CN_FSETTRAPEZ'
* Menu:
BASE CLASSES
------------
* CNFSetLR:: Fuzzy set with L and R functions
DERIVED CLASSES
---------------
* CNFSetTriangle:: Fuzzy set with triangle function
RELATED CLASSES
---------------
DESCRIPTION
-----------
`CNFSetTrapez' realizes a trapezium shaped membership function on
the base of an LR fuzzy set.
Constructors:
`CNFSetTrapez()'
`CNFSetTrapez(CNParam *param);'
`CNFSetTrapez(double xm1, double xm2, double xalpha, double xbeta);'
`CNFSetTrapez(double min, double max, double xm1, double xm2, double xalpha, double xbeta);'
`CNFSetTrapez(CNStringR xname, double xm1, double xm2, double xalpha, double xbeta);'
`CNFSetTrapez(CNStringR xname, double min, double max, double xm1, double xm2, double xalpha, double xbeta);'
Initialize `CNFSetTrapez' with `name' as the object's name. `xm1'
is the x-value of the left maximum, `xm2' of the right one.
`xalpha' is the left and `xbeta' the right slope. `min' and `max'
are the function's minimum / maximum.
In addition to the member functions required by CNCL, `CNFSetTrapez'
provides:
`virtual double get_membership(double x) const;'
Returns the membership value for `x'.
File: cncl.info, Node: CNFSetTriangle, Next: CNFNumTriangle, Prev: CNFSetTrapez, Up: Fuzzy
CNFSetTriangle -- Fuzzy set with triangle function
==================================================
SYNOPSIS
--------
`#include <CNCL/FSetTriangle.h>'
TYPE
----
`CN_FSETTRIANGLE'
* Menu:
BASE CLASSES
------------
* CNFSetTrapez:: Fuzzy set with trapezium functions
DERIVED CLASSES
---------------
* CNFNumTriangle:: Fuzzy number (triangle)
RELATED CLASSES
---------------
DESCRIPTION
-----------
`CNFSetTriangle' realizes a triangle shaped membership function.
Constructors:
`CNFSetTriangle();'
`CNFSetTriangle(CNParam *param);'
`CNFSetTriangle(double xm, double xalpha, double xbeta);'
`CNFSetTriangle(double min, double max, double xm, double xalpha, double xbeta);'
`CNFSetTriangle(CNStringR xname, double xm, double xalpha, double xbeta);'
`CNFSetTriangle(CNStringR xname, double min, double max,double xm, double xalpha, double xbeta);'
Initializes the `CNFSetTriangle'.
In addition to the member functions required by CNCL, `CNFSetTriangle'
provides:
`virtual double get_membership(double x)const;'
Returns the membership value for `x'.
`double get_mean() const;'
Returns the mean value `m1==m2' (maximum).
File: cncl.info, Node: CNFNumTriangle, Next: CNReaderTbl, Prev: CNFSetTriangle, Up: Fuzzy
CNFNumTriangle -- Fuzzy number (triangle)
=========================================
SYNOPSIS
--------
`#include <CNCL/FNumTriangle.h>'
TYPE
----
`CN_FNUMTRIANGLE'
* Menu:
BASE CLASSES
------------
* CNFSetTriangle:: Fuzzy set with triangle functions
DERIVED CLASSES
---------------
RELATED CLASSES
---------------
DESCRIPTION
-----------
`CNFNumTriangle' provides triangle fuzzy set the necessarry
mathematical operations and methods for defuzzification.
Constructors:
`CNFNumTriangle();'
`CNFNumTriangle(CNParam *param);'
`CNFNumTriangle(double m, double a, double b);'
`CNFNumTriangle(const CNFSetTriangle &n);'
Initializes `CNFNumTriangle'.
In addition to the member functions required by CNCL, `CNFNumTriangle'
provides:
`double center_of_gravity(double min, double max)const;'
Returns the center of gravity.
`double defuzzy();'
Returns the defuzzyfied variable.
`CNFNumTriangle sqr(CNFNumTriangle);'
Squares a `CNFNumTriangle' set, using the extension principle.
`CNFNumTriangle abs(CNFNumTriangle);'
Returns the positiv `CNFNumTriangle'.
`CNFNumTriangle &operator =(const CNFNumTriangle &n);'
Sets this `CNFNumTriangle' to `n'.
`CNFNumTriangle operator +(CNFNumTriangle, CNFNumTriangle);'
`CNFNumTriangle operator -(CNFNumTriangle, CNFNumTriangle);'
`CNFNumTriangle operator *(CNFNumTriangle, double);'
`CNFNumTriangle operator *(double, CNFNumTriangle);'
Adds/ substracts two `CNFNumTriangle' sets or multiplies one with a
double (extension principle).
File: cncl.info, Node: Persistent, Prev: Fuzzy, Up: Top
Persistent Classes
******************
The classes described here provide the possibility of persistent
objects. As in most cases it is not necessary to have all the overhead
for persistency inside of a running program, no complete new class need
to be designed if persistency is needed. It is sufficient to add an
extension to a CNCL-kompatible class where all necessary methods are
included.
To generate new persistent classes or extensions, derived from any
`CNCL' compatible class, the utility `CNpersistent' is provided. It
generates a class framework with all functions required by CNCL and all
necesarry methods for persistency.
Usage:
`CNpersistent'[-l] [-t template-dir] basename
The required parameter `basename' is the name of the base class.
This sript will produce the persistent extension to the mentioned base
class. The result are two files in the current directory:
`P'basename`.h' (header file) and `P'basename`.c' (implementation file).
The optional parameters are:
* [-l] : The base class is stored in the local directory, not in the
standard CNCL-tree.
* [-t template-dir] : template-dir is the directory where the
templates will be found (if they are not in the standard
directory).
Example:
CNpersistent MyClass
creates the class/extension files `PMyClass.h' and `PMyClass.c'.
MyClass and CNPObjectID will be the base classes to the new extension.
The only methods that have to be defined after this are the read_from
constructor and the storer-method.
NOTE:
* At some classes it will be necessary to achieve direct access to
some private members of the base class, e.g. for the read_from
constructor or the storer-method. In order to achieve this it is
important to declare the persistent class or extension as friend
class at the base class.
* All extensions have the complete Default I/O member function for
CNCL classes. In most cases this I/O is not necessary because all
these functions are already defined in the base class. Thus all
of them can be deleted (they are marked with the note ( to be
deleted if not needed )).
* Please don't wonder that the rule of no multiple inheritance
inside of CNCL seems to be broken at the persistent classes. The
second base class, `CNPObjectID', is not derived from any other
CNCL-class. So the problems of multiple inheritance can not occur.
* Menu:
Persistent
---------
* CNReaderTbl:: Table for adress of reader-function
* CNPObjectID:: ID-Managment for persistent Objects
* CNPIO:: persistent stream Object IO-formatting
* CNPstream:: abstract base class for persistent stream classes
* CNPiostream:: persistent iostream format
* CNPInt:: class persistent CNInt
* Other CNP<type>:: Other persistent classes
File: cncl.info, Node: CNReaderTbl, Next: CNPObjectID, Prev: CNFNumTriangle, Up: Persistent
CNReaderTbl - Table for adress of reader-function
=================================================
SYNOPSIS
--------
`#include <CNCL/ReaderTbl.h>'
TYPE
----
`CN_READERTBL'
* Menu:
BASE CLASSES
------------
* CNCL:: CNCL Static Members and Functions
DERIVED CLASSES
---------------
RELATED CLASSES
---------------
DESCRIPTION
-----------
`CNReaderTbl' provides a table of all persistent classes
(`Reader-Table') and a second table of id's `ID-Table'. Both tables are
realized as dynamic hash-tables.
The first one uses the classname as key for registering in the table,
the object stored in it is the reader function pointer (the adress of
the reader-function). This table is for checking if a class is
registered to be persistent and for calling the reader constructor when
objects are taken from the stream.
The other table uses the id as key and stores the according object to
this id. The table is used during two occasions. First whenever an
object is written to the stream the id is stored in this table. When
the same object should be stored again it will be recognized. In
addition to the id a special delimitation character is used for
indicating this. When the objects are taken from the stream all objects
and their old id are stored in this table again. When this special
delimitation character apears on the stream the object can be taken out
of the table by its id. Thus it is possible to restore containers even
if one object appears several times at different locations, e.g at a
double linked list.
Constructors:
`CNReaderTbl(char* classname, Reader_ptr reader_ptr);'
Initializes a new Reader Table entry. Each given `classname' is
added to the table.
Additional types provided by `CNReaderTbl' are:
`typedef CNObject*(*Reader_ptr)(CNPstream&);'
This is the type for the reader-function-pointer.
The functions provided by `CNReaderTbl' are:
`static Reader_ptr reader_pointer_by_classname(char* classname);'
This function checks if the requested `classname' is registered in
the Reader Table and returns the according Reader_ptr. If it is not
registered, a fatal error is yielded.
`static bool is_in(long id_key);'
Checks if the given `id_key' is in the id table.
`static void add_to_id_tbl(long id_key, CNObject* obj);'
`static void add_to_id_tbl(long id_key, CNObject& obj);'
Adds the persistent object `obj' to the id table with `id_key' as
its key.
`static CNObject* get_from_id_tbl(long id_key);'
Returns the persistent object stored in the id table with `id_key'
as the key.
`static void reset_id_tbl();'
Resets the id table to its initial state (all stored elemts are
deleted). This method should be used if You change from the
`write-to-stream' to the `read_from_stream' sequence.
File: cncl.info, Node: CNPObjectID, Next: CNPIO, Prev: CNReaderTbl, Up: Persistent
PObjectID -- ID-Managment for persistent Objects
================================================
SYNOPSIS
--------
`#include <CNCL/PObjectID.h>'
TYPE
----
* Menu:
BASE CLASSES
------------
DERIVED CLASSES
---------------
RELATED CLASSES
---------------
DESCRIPTION
-----------
This class manages the (unique) identification number of each
persistent object. All persistent classes must be derived from this
class. As `CNPObjectID' is not derived from any CNCL-class `multiple
inheritance' can be used.
One of the member variables, declared as static, is the counter for
the actual id. It is increased whenever a new id is given to an object.
The other one is the id of the object itself. This number cannot occur
two times inside of one program.
Constructors:
`CNPObjectID();'
Initializes the id and increases the `static' counter. This
constructor must be called in all constructors of the derived
classes.
Additional types provided by `CNReaderTbl' are:
`typedef long PID'
For a possible future change from long to any other larger number
this typedef has been included.
`CNPObjectID' provides the following functions:
`CNPID object_id();'
Returns the object id.
File: cncl.info, Node: CNPIO, Next: CNPstream, Prev: CNPObjectID, Up: Persistent
CNPIO -- persistent stream Object IO-formatting
===============================================
SYNOPSIS
--------
`#include <CNCL/PIO.h>'
TYPE
----
`CN_PIO'
* Menu:
BASE CLASSES
------------
* CNCL:: CNCL Static Members and Functions
DERIVED CLASSES
---------------
RELATED CLASSES
---------------
DESCRIPTION
-----------
`CNPIO' provides the format of storing and reading the persistent
objects on/from a stream.The format convention can be described as
follows:
`classname'
`delimitation character'
`data'
`delimitation character'
The functions provided by `CNPIO' are:
`static int store_object(CNPstream& stream, CNObject& obj, bool no_ptr_check = FALSE);'
`static CNObject* read_object(CNPstream& stream);'
Reads/Stores a persistent `CNObject' on the `stream'. A `CNObject'
is recognized to be persistent if it is registered at the actual
`Reader Table'. `no_ptr_check' determines if the objects are
checked for multiple appearence (`no_ptr_check = FALSE') or not
(`TRUE').
Stores the id of the persistent object `obj' to the given stream.
`static CNPID read_id(CNPstream& stream);'
Reads the id from a stream.
File: cncl.info, Node: CNPstream, Next: CNPiostream, Prev: CNPIO, Up: Persistent
CNPstream -- abstract base class for persistent stream classes
==============================================================
SYNOPSIS
--------
`#include <CNCL/Pstream.h>'
TYPE
----
`CN_PSTREAM'
* Menu:
BASE CLASSES
------------
* CNObject:: Root of the CNCL Hierarchy
DERIVED CLASSES
---------------
RELATED CLASSES
---------------
DESCRIPTION
-----------
`CNPstream' is the abstract base class for the persistent stream
classes. Thus, only IO-operators and IO-functions are defined here. The
concrete definition of the methods and operators must be done in the
derived classes. Thus by this approach the possibilities of
polymorphism are kept.
Constructors:
`CNPstream();'
`CNPstream(*param);'
Initializes the `CNPstream'.
In addition to the member functions required by CNCL, `CNstream'
provides:
`virtual CNPstream& operator<<(const char*)=0;'
`virtual CNPstream& operator<<(char)=0;'
`virtual CNPstream& operator<<(long)=0;'
`virtual CNPstream& operator<<(double)=0;'
`virtual CNPstream& operator>>(char*)=0;'
`virtual CNPstream& operator>>(char&)=0;'
`virtual CNPstream& operator>>(long&)=0;'
`virtual CNPstream& operator>>(double&)=0;'
Virtual persistent IO operators.
`virtual CNPstream& getline(char*, int ) = 0;'
Virtual `getline' function for string input.
File: cncl.info, Node: CNPiostream, Next: CNPInt, Prev: CNPstream, Up: Persistent
CNPiostream -- persistent iostream format
=========================================
SYNOPSIS
--------
`#include <CNCL/Piostream.h>'
TYPE
----
`CN_PIOSTREAM'
* Menu:
BASE CLASSES
------------
* CNPstream:: abstract base class for persistent stream classes
DERIVED CLASSES
---------------
RELATED CLASSES
---------------
DESCRIPTION
-----------
The class `CNPiostream' manages the interface to the gnu c++
iostream library. Thus, all virtual functions of the base class
`CNPstream' are defined here. For a description see the base class.
Constructors:
`CNPiostream(iostream& s);'
`CNPiostream(CNParam *param);'
Initializes the `CNPiostream'.